Probing the value sync's repair paths (follow-up territory from #2965) surfaced this: send an editor a mid-session update value whose changed block has a child missing its _key, and the editor ends up holding that keyless child, a shape its own addressing model can't represent (React immediately warns about duplicate keys rendering it), while the document receives a repair patch the editor never applied to itself.

The mechanism: validateValue runs at sync ingress and can auto-resolve certain defects (child missing _key, empty children, unused markDefs). But the resolution existed only as patches. The changed-block path emitted them outbound (gated to mid-session, non-readOnly, with a console.warn) while passing the raw block into updateBlock/replaceBlock; the insert path computed them and dropped them entirely. So the repair forked: the document got the resolution's minted key, the engine got the un-repaired block, and engine normalization later minted a different key for the same node. The old test pins are the fossil record of this double mint, pteWarningsSelfSolving expected k3, the key normalization minted after validateValue's k2 was discarded.

The fix applies the resolution to the block before it enters the engine, at both call sites, via applyAll from @portabletext/patches (the same constructors validateValue builds its resolutions with). The emitted patches are byte-identical to before and now agree with engine state: one key, minted once, on both sides. Emission semantics are deliberately untouched, the insert path still emits nothing, the changed path still emits only mid-session for non-readOnly editors; changing when repairs are emitted is the pending-events design work, tracked separately.

Three regression scenarios in event.update-value.test.tsx pin the contract: a mid-session keyless-child update repairs once (emitted patch key === engine key, exact values) and the sync survives to apply a subsequent update; a mid-session update with an unused markDef repairs on both sides, where the pre-fix red exposed a second defect of the fork: the repair was doubly emitted, the ingress keyed unset plus the engine normalizer's whole-array set for the same def, two conflicting patch shapes for one repair; and a startup value with a keyless child is repaired in the engine while emitting nothing (no mutation leaves a pristine editor on open). Negative assertions use a causal sentinel (one local edit, then a full-literal assert of the entire emission history) instead of sleeps, so a would-be emission is caught by ordering, not timing. The survival assertion needs a beat over a second: the sync machine parks in busy while its own emitted mutation flushes and re-polls on a 1s timer, which is also worth naming because an earlier probe mistook that delay for a permanent wedge; there is no wedge, the machine recovers by design.

Semantic deltas, all deliberate and pinned: repaired blocks now carry the first mint's key (pteWarningsSelfSolving, container-normalization pins shift from the second mint to the first), and an empty-children block arrives with its placeholder span inside the block's own insert operation instead of as a separate normalization fix op (event.operation). The normalization-adjacency contract that scenario used to exercise is re-pinned on duplicate child keys, which have no ingress check and are still repaired by normalization, so the contract keeps a living fixture. Full unit (852) and browser (1718) suites pass.